package com.xkcyy.one.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xkcyy.one.entity.Tool;
import com.xkcyy.one.exception.BusinessException;
import com.xkcyy.one.mapper.ToolMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 工具服务类
 * 
 * @author yuand
 */
@Service
public class ToolService {

    private final ToolMapper toolMapper;

    @Autowired
    public ToolService(ToolMapper toolMapper) {
        this.toolMapper = toolMapper;
    }

    /**
     * 获取所有工具
     *
     * @return 工具列表
     */
    public List<Tool> getAllTools() {
        return toolMapper.selectList(null);
    }

    /**
     * 根据用户ID获取工具列表
     *
     * @param userId 用户ID
     * @return 工具列表
     */
    public List<Tool> getToolsByUserId(Long userId) {
        LambdaQueryWrapper<Tool> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tool::getUserId, userId);
        return toolMapper.selectList(queryWrapper);
    }

    /**
     * 根据状态获取工具列表
     *
     * @param status 状态
     * @return 工具列表
     */
    public List<Tool> getToolsByStatus(String status) {
        LambdaQueryWrapper<Tool> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tool::getStatus, status);
        return toolMapper.selectList(queryWrapper);
    }

    /**
     * 根据ID获取工具
     *
     * @param id 工具ID
     * @return 工具
     */
    public Tool getToolById(Long id) {
        Tool tool = toolMapper.selectById(id);
        if (tool == null) {
            throw new BusinessException("工具不存在，ID: " + id);
        }
        return tool;
    }

    /**
     * 创建工具
     *
     * @param tool 工具
     * @return 创建后的工具
     */
    public Tool createTool(Tool tool) {
        // 检查名称是否已存在
        LambdaQueryWrapper<Tool> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tool::getName, tool.getName());
        if (toolMapper.selectCount(queryWrapper) > 0) {
            throw new BusinessException("工具名称已存在: " + tool.getName());
        }

        // 设置默认值
        tool.setVersion(1);
        tool.setStatus(Tool.Status.DEV);

        // 设置创建时间和更新时间
        LocalDateTime now = LocalDateTime.now();
        tool.setCreateTime(now);
        tool.setUpdateTime(now);

        // 插入工具
        toolMapper.insert(tool);

        return tool;
    }

    /**
     * 更新工具
     *
     * @param tool 工具
     * @return 更新后的工具
     */
    public Tool updateTool(Tool tool) {
        // 检查工具是否存在
        Tool existingTool = toolMapper.selectById(tool.getId());
        if (existingTool == null) {
            throw new BusinessException("工具不存在，ID: " + tool.getId());
        }

        // 检查名称是否已被其他工具使用
        LambdaQueryWrapper<Tool> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tool::getName, tool.getName())
                .ne(Tool::getId, tool.getId());
        if (toolMapper.selectCount(queryWrapper) > 0) {
            throw new BusinessException("工具名称已存在: " + tool.getName());
        }

        // 保持版本号不变
        tool.setVersion(existingTool.getVersion());

        // 设置更新时间
        tool.setUpdateTime(LocalDateTime.now());

        // 更新工具
        toolMapper.updateById(tool);

        return tool;
    }

    /**
     * 删除工具
     *
     * @param id 工具ID
     */
    public void deleteTool(Long id) {
        // 检查工具是否存在
        Tool existingTool = toolMapper.selectById(id);
        if (existingTool == null) {
            throw new BusinessException("工具不存在，ID: " + id);
        }

        // 删除工具
        toolMapper.deleteById(id);
    }

    /**
     * 更新工具状态
     *
     * @param id     工具ID
     * @param status 新状态
     * @return 更新后的工具
     */
    public Tool updateToolStatus(Long id, String status) {
        Tool tool = toolMapper.selectById(id);
        if (tool == null) {
            throw new BusinessException("工具不存在，ID: " + id);
        }

        tool.setStatus(status);
        tool.setUpdateTime(LocalDateTime.now());
        toolMapper.updateById(tool);

        return tool;
    }

    /**
     * 根据实现类型获取工具列表
     *
     * @param implementationType 实现类型
     * @return 工具列表
     */
    public List<Tool> getToolsByImplementationType(String implementationType) {
        LambdaQueryWrapper<Tool> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tool::getImplementationType, implementationType);
        return toolMapper.selectList(queryWrapper);
    }

    /**
     * 根据脚本ID获取相关工具列表
     *
     * @param scriptId 脚本ID
     * @return 工具列表
     */
    public List<Tool> getToolsByScriptId(Long scriptId) {
        LambdaQueryWrapper<Tool> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Tool::getScriptId, scriptId)
                .eq(Tool::getImplementationType, Tool.ImplementationType.SCRIPT);
        return toolMapper.selectList(queryWrapper);
    }
}